//给你一个 rows x cols 的矩阵 grid 来表示一块樱桃地。 grid 中每个格子的数字表示你能获得的樱桃数目。 
//
// 你有两个机器人帮你收集樱桃，机器人 1 从左上角格子 (0,0) 出发，机器人 2 从右上角格子 (0, cols-1) 出发。 
//
// 请你按照如下规则，返回两个机器人能收集的最多樱桃数目： 
//
// 
// 从格子 (i,j) 出发，机器人可以移动到格子 (i+1, j-1)，(i+1, j) 或者 (i+1, j+1) 。 
// 当一个机器人经过某个格子时，它会把该格子内所有的樱桃都摘走，然后这个位置会变成空格子，即没有樱桃的格子。 
// 当两个机器人同时到达同一个格子时，它们中只有一个可以摘到樱桃。 
// 两个机器人在任意时刻都不能移动到 grid 外面。 
// 两个机器人最后都要到达 grid 最底下一行。 
// 
//
// 
//
// 示例 1： 
//
// 
//
// 输入：grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]]
//输出：24
//解释：机器人 1 和机器人 2 的路径在上图中分别用绿色和蓝色表示。
//机器人 1 摘的樱桃数目为 (3 + 2 + 5 + 2) = 12 。
//机器人 2 摘的樱桃数目为 (1 + 5 + 5 + 1) = 12 。
//樱桃总数为： 12 + 12 = 24 。
// 
//
// 示例 2： 
//
// 
//
// 输入：grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1
//,0,2,3,0,0,6]]
//输出：28
//解释：机器人 1 和机器人 2 的路径在上图中分别用绿色和蓝色表示。
//机器人 1 摘的樱桃数目为 (1 + 9 + 5 + 2) = 17 。
//机器人 2 摘的樱桃数目为 (1 + 3 + 4 + 3) = 11 。
//樱桃总数为： 17 + 11 = 28 。
// 
//
// 示例 3： 
//
// 输入：grid = [[1,0,0,3],[0,0,0,3],[0,0,3,3],[9,0,3,3]]
//输出：22
// 
//
// 示例 4： 
//
// 输入：grid = [[1,1],[1,1]]
//输出：4
// 
//
// 
//
// 提示： 
//
// 
// rows == grid.length 
// cols == grid[i].length 
// 2 <= rows, cols <= 70 
// 0 <= grid[i][j] <= 100 
// 
//
// Related Topics 数组 动态规划 矩阵 👍 82 👎 0


package com.tyrone.leetcode.editor.cn;

import java.util.Arrays;

public class CherryPickupIi {
    public static void main(String[] args) {
        Solution solution = new CherryPickupIi().new Solution();
        System.out.println(solution.cherryPickup(new int[][]{{3, 1, 1}, {2, 5, 1}, {1, 5, 5}, {2, 1, 1}}));
    }

    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        /**
         * 一看就是动态规划的解法 两个机器人无非就是初始状态的问题，现在开始的想法
         * 是把他们找过路径都筛选出来 这样肯定是错的
         *
         * @param grid
         * @return
         */
//        public int cherryPickup(int[][] grid) {
//            int m = grid.length;
//            int n = grid[0].length;
//            boolean[][] dp = new boolean[m][n];
//        }
        public int cherryPickup(int[][] grid) {
            int m = grid.length;
            int n = grid[0].length;
            int[][] curr = new int[n][n];  //表示dp[i][j] robot1到达当前行的i，robot2到达当前行的j的时候的最大值
            int[][] before = new int[n][n]; //表示dp[i][j] robot1到达上一行的i，robot2到达当前行的j的时候的最大值

            for (int i = 0; i < n; i++) {
                Arrays.fill(curr[i], -1);
                Arrays.fill(before[i], -1);
            }
            before[0][n-1] = grid[0][0] + grid[0][n - 1];
            for (int i = 1; i < m; i++) {
                //robot1到达的位置
                for (int j1 = 0; j1 < n; j1++) {
                    //robot1到达的位置
                    for (int j2 = 0; j2 < n; j2++) {
                        int max = -1;
                        //robot1 转移的范围下一行（-1，0，1）
                        for (int dj1 = j1 - 1; dj1 <= j1 + 1; dj1++) {
                            //robot2 转移的范围下一行（-1，0，1）
                            for (int dj2 = j2 - 1; dj2 <= j2 + 1; dj2++) {
                                if (dj1 >= 0 && dj1 < n && dj2 >= 0 && dj2 < n && before[dj1][dj2] != -1) {
                                    max = Math.max(max, before[dj1][dj2] + (j1 == j2 ? grid[i][j1] : grid[i][j1] + grid[i][j2]));
                                }
                            }
                        }
                        curr[j1][j2] = max;
                    }
                }
                int[][] temp = before;
                before  = curr;
                curr = temp;
            }
            //现在棋盘里面为true是机器人可能会走的所有路径
            int ans = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    ans = Math.max(before[i][j],ans);
                }
            }
            return ans;
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

}